package cn.jasonone.tio.tcp;

import cn.hutool.core.lang.Assert;
import lombok.Getter;
import org.springframework.stereotype.Component;
import org.tio.client.ClientTioConfig;
import org.tio.core.*;
import org.tio.core.intf.Packet;
import org.tio.utils.lock.ReadLockHandler;
import org.tio.utils.lock.SetWithLock;

import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class TioMessage {
    @Getter
    private static TioConfig tioConfig;

    /**
     * 获取所有连接，包括当前处于断开状态的
     *
     * @return
     * @author tanyaowu
     */
    public static SetWithLock<ChannelContext> getAll() {
        return Tio.getAll(tioConfig);
    }

    /**
     * 此API仅供 tio client使用
     * 获取所有处于正常连接状态的连接
     *
     * @return
     * @author tanyaowu
     */
    public static SetWithLock<ChannelContext> getConnecteds() {
        Assert.isTrue(tioConfig instanceof ClientTioConfig, "当前方法仅支持客户端调用");
        return Tio.getConnecteds((ClientTioConfig) tioConfig);
    }

    /**
     * 根据业务id找ChannelContext
     *
     * @param bsId
     * @return
     * @author tanyaowu
     */
    public static ChannelContext getByBsId(String bsId) {
        return Tio.getByBsId(tioConfig, bsId);
    }

    /**
     * 根据clientip和clientport获取ChannelContext
     *
     * @param clientIp
     * @param clientPort
     * @return
     * @author tanyaowu
     */
    public static ChannelContext getByClientNode(String clientIp, Integer clientPort) {
        return Tio.getByClientNode(tioConfig, clientIp, clientPort);
    }

    /**
     * 获取一个组的所有客户端
     *
     * @param group
     * @return
     * @author tanyaowu
     */
    public static SetWithLock<ChannelContext> getByGroup(String group) {
        return Tio.getByGroup(tioConfig, group);
    }

    /**
     * 根据token获取SetWithLock<ChannelContext>
     *
     * @param token
     * @return
     * @author tanyaowu
     */
    public static SetWithLock<ChannelContext> getByToken(String token) {
        return Tio.getByToken(tioConfig, token);
    }

    /**
     * 根据客户端ip获取SetWithLock<ChannelContext>
     *
     * @param ip
     * @return
     * @author tanyaowu
     */
    public static SetWithLock<ChannelContext> getByIp(String ip) {
        return Tio.getByIp(tioConfig, ip);
    }


    /**
     * 根据userid获取SetWithLock<ChannelContext>
     *
     * @param userid
     * @return
     * @author tanyaowu
     */
    public static SetWithLock<ChannelContext> getByUserid(String userid) {
        return Tio.getByUserid(tioConfig, userid);
    }

    /**
     * 群组有多少个连接
     *
     * @param group
     * @return
     */
    public static int groupCount(String group) {
        return Tio.groupCount(tioConfig, group);
    }

    /**
     * 绑定业务id
     *
     * @param channelContext
     * @param bsId
     * @author tanyaowu
     */
    public static void bindBsId(ChannelContext channelContext, String bsId) {
        Tio.bindBsId(channelContext, bsId);
    }

    /**
     * 绑定群组
     *
     * @param channelContext
     * @param group
     * @author tanyaowu
     */
    public static void bindGroup(ChannelContext channelContext, String group) {
        Tio.bindGroup(channelContext, group);
    }

    /**
     * 将用户绑定到群组
     *
     * @param tioConfig
     * @param userid
     * @param group
     */
    public static void bindGroup(String userid, String group) {
        Tio.bindGroup(tioConfig, userid, group);
    }

    /**
     * 绑定token
     *
     * @param channelContext
     * @param token
     * @author tanyaowu
     */
    public static void bindToken(ChannelContext channelContext, String token) {
        Tio.bindToken(channelContext, token);
    }

    /**
     * 绑定用户
     *
     * @param channelContext
     * @param userid
     * @author tanyaowu
     */
    public static void bindUser(ChannelContext channelContext, String userid) {
        Tio.bindUser(channelContext, userid);
    }

    /**
     * 阻塞发送消息到指定ChannelContext
     *
     * @param channelContext
     * @param packet
     * @return
     * @author tanyaowu
     */
    public static Boolean bSend(ChannelContext channelContext, Packet packet) {
        return Tio.bSend(channelContext, packet);
    }

    /**
     * 发送到指定的ip和port
     *
     * @param ip
     * @param port
     * @param packet
     * @author tanyaowu
     */
    public static Boolean bSend(String ip, int port, Packet packet) {
        return Tio.bSend(tioConfig, ip, port, packet);
    }

    /**
     * 发消息到所有连接
     *
     * @param packet
     * @param channelContextFilter
     * @author tanyaowu
     */
    public static Boolean bSendToAll(Packet packet, ChannelContextFilter channelContextFilter) {
        return Tio.bSendToAll(tioConfig, packet, channelContextFilter);
    }

    /**
     * 阻塞发消息给指定业务ID
     *
     * @param bsId
     * @param packet
     * @author tanyaowu
     */
    public static Boolean bSendToBsId(String bsId, Packet packet) {
        return Tio.bSendToBsId(tioConfig, bsId, packet);
    }

    /**
     * 发消息到组
     *
     * @param group
     * @param packet
     * @author tanyaowu
     */
    public static Boolean bSendToGroup(String group, Packet packet) {
        return Tio.bSendToGroup(tioConfig, group, packet);
    }

    /**
     * 发消息到组
     *
     * @param group
     * @param packet
     * @param channelContextFilter
     * @author tanyaowu
     */
    public static Boolean bSendToGroup(String group, Packet packet, ChannelContextFilter channelContextFilter) {
        return Tio.bSendToGroup(tioConfig, group, packet, channelContextFilter);
    }

    /**
     * 发消息给指定ChannelContext id
     *
     * @param channelContextId
     * @param packet
     * @author tanyaowu
     */
    public static Boolean bSendToId(String channelContextId, Packet packet) {
        return Tio.bSendToId(tioConfig, channelContextId, packet);
    }

    /**
     * 阻塞发送到指定ip对应的集合
     *
     * @param ip
     * @param packet
     * @author: tanyaowu
     */
    public static Boolean bSendToIp(String ip, Packet packet) {
        return Tio.bSendToIp(tioConfig, ip, packet);
    }

    /**
     * 阻塞发送到指定ip对应的集合
     *
     * @param ip
     * @param packet
     * @param channelContextFilter
     * @return
     * @author: tanyaowu
     */
    public static Boolean bSendToIp(String ip, Packet packet, ChannelContextFilter channelContextFilter) {
        return Tio.bSendToIp(tioConfig, ip, packet, channelContextFilter);
    }

    /**
     * 发消息到指定集合
     *
     * @param setWithLock
     * @param packet
     * @param channelContextFilter
     * @author tanyaowu
     */
    public static Boolean bSendToSet(SetWithLock<ChannelContext> setWithLock, Packet packet, ChannelContextFilter channelContextFilter) {
        return Tio.bSendToSet(tioConfig, setWithLock, packet, channelContextFilter);
    }

    /**
     * 阻塞发消息到指定token
     *
     * @param token
     * @param packet
     * @return
     * @author tanyaowu
     */
    public static Boolean bSendToToken(String token, Packet packet) {
        return Tio.bSendToToken(tioConfig, token, packet);
    }

    /**
     * 阻塞发消息给指定用户
     *
     * @param userid
     * @param packet
     * @return
     * @author tanyaowu
     */
    public static Boolean bSendToUser(String userid, Packet packet) {
        return Tio.bSendToUser(tioConfig, userid, packet);
    }

    /**
     * 发送消息到指定ChannelContext
     *
     * @param channelContext
     * @param packet
     * @author tanyaowu
     */
    public static Boolean send(ChannelContext channelContext, Packet packet) {
        return Tio.send(channelContext, packet);
    }

    /**
     * 发送到指定的ip和port
     *
     * @param ip
     * @param port
     * @param packet
     * @author tanyaowu
     */
    public static Boolean send(String ip, int port, Packet packet) {
        return Tio.send(tioConfig, ip, port, packet);
    }


    public static void sendToAll(Packet packet) {
        Tio.sendToAll(tioConfig, packet);
    }

    /**
     * 发消息到所有连接
     *
     * @param packet
     * @param channelContextFilter
     * @author tanyaowu
     */
    public static void sendToAll(Packet packet, ChannelContextFilter channelContextFilter) {
        Tio.sendToAll(tioConfig, packet, channelContextFilter);
    }


    /**
     * 发消息给指定业务ID
     *
     * @param bsId
     * @param packet
     * @return
     * @author tanyaowu
     */
    public static Boolean sendToBsId(String bsId, Packet packet) {
        return Tio.sendToBsId(tioConfig, bsId, packet);
    }


    /**
     * 发消息到组
     *
     * @param group
     * @param packet
     * @author tanyaowu
     */
    public static void sendToGroup(String group, Packet packet) {
        Tio.sendToGroup(tioConfig, group, packet);
    }

    /**
     * 发消息到组
     *
     * @param group
     * @param packet
     * @param channelContextFilter
     * @author tanyaowu
     */
    public static void sendToGroup(String group, Packet packet, ChannelContextFilter channelContextFilter) {
        Tio.sendToGroup(tioConfig, group, packet, channelContextFilter);
    }


    /**
     * 发消息给指定ChannelContext id
     *
     * @param channelContextId
     * @param packet
     * @author tanyaowu
     */
    public static Boolean sendToId( String channelContextId, Packet packet) {
        return Tio.sendToId(tioConfig, channelContextId, packet);
    }

    /**
     * 发送到指定ip对应的集合
     *
     * @param ip
     * @param packet
     * @author: tanyaowu
     */
    public static void sendToIp(String ip, Packet packet) {
        Tio.sendToIp(tioConfig, ip, packet);
    }

    /**
     * 发送到指定ip对应的集合
     *
     * @param ip
     * @param packet
     * @param channelContextFilter
     * @author: tanyaowu
     */
    public static void sendToIp(String ip, Packet packet, ChannelContextFilter channelContextFilter) {
        Tio.sendToIp(tioConfig, ip, packet, channelContextFilter);
    }


    /**
     * 发消息到指定集合
     *
     * @param setWithLock
     * @param packet
     * @param channelContextFilter
     * @author tanyaowu
     */
    public static void sendToSet(SetWithLock<ChannelContext> setWithLock, Packet packet, ChannelContextFilter channelContextFilter) {
        Tio.sendToSet(tioConfig, setWithLock, packet, channelContextFilter);
    }

    /**
     * 发消息到指定token
     *
     * @param token
     * @param packet
     * @return
     * @author tanyaowu
     */
    public static Boolean sendToToken(String token, Packet packet) {
        return Tio.sendToToken(tioConfig, token, packet);
    }

    /**
     * 发消息给指定用户
     *
     * @param userid
     * @param packet
     * @author tanyaowu
     */
    public static Boolean sendToUser(String userid, Packet packet) {
        return Tio.sendToUser(tioConfig, userid, packet);
    }

}
